package com.weipu.common.facade.support.service.task;

import java.util.ArrayList;

import com.weipu.common.facade.model.config.ConfigUtil;
import com.weipu.common.facade.support.service.TaskExecutor;
import com.weipu.common.util.CacheUtil;
import com.weipu.common.util.GlobalConfig;
import com.weipu.common.util.Logger;
import com.weipu.common.util.ThreadUtil;

/**
 * 启动初始化任务任务
 */
public class StartupTask extends BaseServiceTask<Boolean>
{
    /**
     * SN
     */
    private static final long serialVersionUID = 3865077020247732395L;
    
    private static final String TAG="StartupTask";
    
    @Override
    protected boolean executeRequest()
    {
        return true;
    }
    
    //任务执行概要： 产品链表任务、目录链表任务(依赖于产品链表最后一个任务完成)    
    @Override
    protected Boolean execute()
    {
        //【目录列表任务链】
        BaseServiceTask<?> firstCategoryTask = null;
        
        //是否允许预加载栏目数据
        boolean isEnablePreLoadCategory =
            ConfigUtil.getInstance().getConfig().getStartupConfig().isEnablePreLoadCategory()
                && CacheUtil.getInstance().isEnablePreLoad();
        Logger.i(TAG, "isEnablePreLoadCategory "+isEnablePreLoadCategory);
        //1、预加载开关打开
        //2、线程池数量有限制则认为当前设备配置较低(getSupportMaxPoolSize >= 0)，不适合做栏目做预加载
        if (isEnablePreLoadCategory && ThreadUtil.getInstance().getSupportMaxPoolSize() < 0)
        {
        	Logger.i(TAG, "loadCategoryTask to create new Category Task ");
            firstCategoryTask = loadCategoryTask(null);//无子任务列表
        }
        
        //【产品列表任务链】
        BaseServiceTask<?> firstProductTask = null;
        //是否允许预加载挂牌数据
        boolean isEnablePreLoadProduct =
            ConfigUtil.getInstance().getConfig().getStartupConfig().isEnablePreLoadProduct()
                && CacheUtil.getInstance().isEnablePreLoad();
        Logger.i(TAG, "isEnablePreLoadProduct "+isEnablePreLoadProduct);
        //1、预加载开关打开
        //2、线程池数量有限制则认为当前设备配置较低(getSupportMaxPoolSize >= 0)，不适合做栏目做预加载
        if (isEnablePreLoadProduct && ThreadUtil.getInstance().getSupportMaxPoolSize() < 0)
        {
        	Logger.i(TAG, "loadCategoryTask to create new Product Task ");
            firstProductTask = loadProductTask(firstCategoryTask);//产品列表加载结束后再加载目录列表
        }
        
        //【初始化启动任务】
        BaseServiceTask<?> startupTask = null;
        //首页默认启动产品列表任务
        startupTask = firstProductTask;
        //初始化产品加载任务为空，则加载目录任务
        if (null == startupTask)
        {
        	Logger.i(TAG, "firstProductTask is null!");
            startupTask = firstCategoryTask;
        }
        
        //只要有一个任务不为空则执行初始化任务
        if (null != startupTask)
        {
            TaskExecutor.doTaskInBackground(startupTask);
        }
        
        return true;
    }
    
    /**
     * 加载产品数据，制作任务链，并将首任务对象返回
     * @param childDependTask 当前任务链最后一个元素需要连接的子任务(在当前任务链执行结束之后调用该子任务)
     * @return 根任务
     */
    private BaseServiceTask<?> loadProductTask(BaseServiceTask<?> childDependTask)
    {
        //默认加载"NewArrival"，所以此处不用预加载
        String[] promotionProduct = {"topsellers", "gadgets", "Clearance"};
        
        //第一个根任务
        GetProductListByCategoryIdAndRelatedTypeTask firstTask = null;
        
        //上一任务
        GetProductListByCategoryIdAndRelatedTypeTask previousTask = null;
        
        //下一任务
        GetProductListByCategoryIdAndRelatedTypeTask nextTask = null;
        
        int len = promotionProduct.length;
        
        //单个任务延时加载
        int taskDelay = len * 300;
        
        for (int i = 0; i < len; i++)
        {
            //创建新任务
            nextTask =
                new GetProductListByCategoryIdAndRelatedTypeTask(1, 16, "d=Popularity", 0, Double.MAX_VALUE, 0.00,
                    promotionProduct[i], false);
            
            nextTask.setDelay(taskDelay);//每个任务延迟
            
            taskDelay -= 300;
            
            // 第一个任务设定
            if (null == previousTask)
            {
                firstTask = nextTask;
            }
            //上一个任务设定关联任务
            else
            {
                previousTask.setNextTask(nextTask);
            }
            
            //设定结束后，新任务变为 previous
            previousTask = nextTask;
        }
        
        //指定任务追加到任务链最后一个元素
        if (null != childDependTask && null != nextTask)
        {
            nextTask.setNextTask(childDependTask);
        }
        
        return firstTask;
    }
    
    /**
     *加载目录数据，制作任务链，并将首任务对象返回
     * @param childDependTask 当前任务链最后一个元素需要连接的子任务(在当前任务链执行结束之后调用该子任务)
     * @return 根任务
     */
    private BaseServiceTask<?> loadCategoryTask(BaseServiceTask<?> childDependTask)
    {
        //预备加载本地二级目录(一级目录已知)
        ArrayList<Integer> rootCategoryID = GlobalConfig.getInstance().getRootCategoryIDList();
        
        //第一个根任务
        GetChildCategoriesTask firstTask = null;
        
        if (null != rootCategoryID && !rootCategoryID.isEmpty())
        {
            
            //上一任务
            GetChildCategoriesTask previousTask = null;
            
            //下一任务
            GetChildCategoriesTask nextTask = null;
            
            int len = rootCategoryID.size();
            
            //单个任务延时加载，累计递减
            int taskDelay = len * 500;
            Logger.i(TAG, "pre loading======create task "+len);
            for (int i = 0; i < rootCategoryID.size(); i++)
            {
            	
                //创建新任务
                nextTask = new GetChildCategoriesTask(rootCategoryID.get(i), false);
                
                nextTask.setDelay(taskDelay);
                
                taskDelay -= 500;
                
                // 第一个任务设定
                if (null == previousTask)
                {
                    firstTask = nextTask;
                }
                //上一个任务设定关联任务
                else
                {
                    previousTask.setNextTask(nextTask);
                }
                
                //设定结束后，新任务变为 previous
                previousTask = nextTask;
            }
            
            //指定任务追加到任务链最后一个元素
            if (null != childDependTask && null != nextTask)
            {
                nextTask.setNextTask(childDependTask);
            }
        }
        return firstTask;
    }
    
    @Override
    public boolean equals(Object o)
    {
        if (!(o instanceof StartupTask))
        {
            return false;
        }
        
        return this.toString().equals(o.toString());
    }
    
    //    equals 返回 true的链各个对象则hashcode必须相等
    @Override
    public int hashCode()
    {
        return toString().hashCode();
    }
    
    //提供Equals对比，单例任务(同一时间只需运行一个)
    @Override
    public String toString()
    {
        return "StartupTask";
    }
    
    @Override
    protected void executeResponse(Boolean result)
    {
        super.executeResponse(result);
    }
    
}
